import csv
import datetime
import re
import time
import schedule
from PIL import ImageGrab
from easyocr import easyocr

# 定义全局变量
start_time = ""
end_time = ""
time_interval = 0.0
top_left_corner_x = 0
top_left_corner_y = 0
bottom_right_corner_x = 0
bottom_right_corner_y = 0
is_GPU = True


# 定义OCR服务
def job():
    # 提示服务执行中
    print("--------------服务执行中--------------")

    # 截屏
    img = ImageGrab.grab(bbox=(top_left_corner_x, top_left_corner_y, bottom_right_corner_x, bottom_right_corner_y))
    img.save('screen_img.png')

    # 初始化 EasyOCR
    reader = easyocr.Reader(['en', 'ch_sim'])

    # 识别截图中的文本
    result = reader.readtext("screen_img.png")

    # 定义临时变量，用于储存每一行的数据
    num = []
    nums = []

    # 使用正则表达式匹配格式为 "xx:xx:xx" 或 "xx;xx;xx" 的元素
    pattern = re.compile(r'^\d{2}[,.:;]\d{2}[,.:;]\d{2}$')

    # 将识别内容在同一行上的元素保存在临时列表中，再将每一行的列表保存在总列表中
    for test in result:
        # 判断迭代到的元素是否符合xx:xx:xx格式，若是则装入临时列表
        if not pattern.match(test[1]):
            # 将数字汉字分开
            combined_chinese, combined_digits = separate_and_combine(test[1])
            if combined_digits:
                num.append(combined_digits)
            if combined_chinese:
                num.append(combined_chinese)
        # 迭代到的元素不是xx:xx:xx格式，替换临时变量为当前元素
        else:
            # 第一个元素不参与处理
            if num:
                # 判断最后一个元素是否为汉字
                if re.compile(r'^[\u4e00-\u9fa5]+$').match(num[-1]):
                    # 临时存储汉字元素
                    n = num[-1]
                    num[-1] = None
                    # 拓展列表
                    while len(num) < 5:
                        num.append(None)
                    # 将汉字元素对齐
                    num[4] = n
                # 将一行的数据存入总列表
                nums.append(num)
                # 重置临时列表，并将新一行的数据装入
                num = [test[1]]
            else:
                num = [result[0][1]]

    # 将识别结果存储在 CSV 文件中
    with open('test.csv', 'a', newline='') as file:
        writer = csv.writer(file)

        # 遍历填入OCR数据
        for row in nums:
            writer.writerow(row)

        # 提示一次服务完成
        print("---------------服务完成---------------")


# 判断元素中是否同时含有数字和汉字
def separate_and_combine(input_string):
    # 使用正则表达式匹配汉字和数字
    chinese_pattern = re.compile(r'[\u4e00-\u9fa5]')  # 汉字的正则表达式
    digit_pattern = re.compile(r'-?\d+\.?\d*')  # 数字的正则表达式

    # 使用正则表达式的findall方法找到所有匹配项
    chinese_chars = chinese_pattern.findall(input_string)
    digits = digit_pattern.findall(input_string)

    # 将汉字和数字分别连接成一个整体
    combined_chinese = ''.join(chinese_chars)
    combined_digits = ''.join(digits)

    return combined_chinese, combined_digits


# 启动服务
def start_job():
    print("--------------服务已启动--------------")
    schedule.every(int(time_interval)).seconds.do(job)


# 关闭服务
def stop_job():
    print("--------------服务已停止--------------")
    schedule.clear()


# 解析配置文件，初始化配置参数
def initialize():
    # 声明全局变量
    global start_time
    global end_time
    global time_interval
    global top_left_corner_x
    global top_left_corner_y
    global bottom_right_corner_x
    global bottom_right_corner_y
    global is_GPU

    # .properties文件路径
    properties_path = "config.properties"

    # 声明Properties类的实例，调用其read方法，返回字典
    properties = ReadProperties(properties_path).read()

    # 将所有参数都存在字典的value中
    start_time = properties['start_time']
    end_time = properties['end_time']
    time_interval = float(properties['time_interval'])
    top_left_corner_x = int(properties['top_left_corner_x'])
    top_left_corner_y = int(properties['top_left_corner_y'])
    bottom_right_corner_x = int(properties['bottom_right_corner_x'])
    bottom_right_corner_y = int(properties['bottom_right_corner_y'])
    is_GPU = bool(properties['is_GPU'])


# 定义定时任务
def ScheduledTask():
    # 清空任务，保证服务正常执行
    schedule.clear()

    # 定义定时任务，用于启动和停止脚本
    schedule.every().day.at(start_time).do(start_job)
    schedule.every().day.at(end_time).do(stop_job)

    try:
        while True:
            schedule.run_pending()
            time.sleep(time_interval)
    except KeyboardInterrupt:
        print("--------脚本被中断--------")


# 判断当前时间是否符合服务启动要求
def RightNow():
    # 获取当前时间
    now_time = datetime.datetime.now()
    now_time = now_time.strftime("%H:%M")

    # 时间转换，用以比较
    now_time = datetime.datetime.strptime(now_time, "%H:%M")
    start_time01 = datetime.datetime.strptime(start_time, "%H:%M")
    end_time01 = datetime.datetime.strptime(end_time, "%H:%M")

    # 考虑到在一天的纬度上，结束时间可能遭遇开始时间，在这里处理将结束时间加一天便于比较
    if start_time01 > end_time01:
        end_time01 += datetime.timedelta(days=1)

    # 判断当前时间是否在开启和关闭时间之间
    if start_time01 < now_time < end_time01:
        # 创建任务，一定时间间隔内执行
        schedule.every(int(time_interval)).seconds.do(job)

        # 提示启动服务成功
        print("---------------启动成功---------------")
        while True:
            schedule.run_pending()


# 入口函数
def domain():
    # 初始化配置参数
    initialize()

    # 判断当前时间是否符合服务启动要求，若符合则直接启动
    RightNow()

    # 启动服务
    ScheduledTask()


# 读取Properties文件类
class ReadProperties:
    def __init__(self, file_name):
        self.file_name = file_name

    def read(self):
        try:
            pro_file = open(self.file_name, 'r', encoding='utf-8')
            properties = {}
            for line in pro_file:
                if line.find('=') > 0:
                    strs = line.replace('\n', '').split('=')
                    properties[strs[0]] = strs[1]
        except Exception as e:
            raise e
        else:
            pro_file.close()
        return properties


if __name__ == "__main__":
    try:
        domain()
    except KeyboardInterrupt:
        print("---------------程序终止---------------")
